#ifndef MATRIX_ENTRY_CC
#define MATRIX_ENTRY_CC

#include "MatrixEntry.h"

template <typename T>
MatrixEntry<T> :: MatrixEntry(UINT row, UINT col, T value)
{
    setRow(row);
    setCol(col);
    setVal(value);
}

template <typename T>
MatrixEntry<T> :: MatrixEntry(MatrixEntry<T> *copyMe, BOOL transpose)
{
    if (copyMe == NULL) {
        throw MatrixException("NULL passed to constructor");
    }
    if (transpose) {
        _row = copyMe->getCol();
        _col = copyMe->getRow();
        _value = copyMe->getVal();
    } else {
        _row = copyMe->getRow();
        _col = copyMe->getCol();
    }
    _value = copyMe->getVal();
}

template <typename T>
void MatrixEntry<T> :: setRow(UINT row)
{
    _row = row;
}

template <typename T>
void MatrixEntry<T> :: setCol(UINT col)
{
    _col = col;
}

template <typename T>
void MatrixEntry<T> :: setVal(T value)
{
    _value = value;
}

template <typename T>
MatrixEntry<T> :: ~MatrixEntry() throw()
{
    _row = 0;
    _col = 0;
    _value = T();
}

template <typename T>
const T& MatrixEntry<T> :: getVal()
{
    return _value;
}

template <typename T>
UINT MatrixEntry<T> :: getRow()
{
    return _row;
}

template <typename T>
UINT MatrixEntry<T> :: getCol()
{
    return _col;
}

template <typename T>
void MatrixEntry<T> :: print()
{
    cout << "(" << getRow() << ", "
            << getCol() << ",["
            << getVal() << "])" << endl;
}

template <typename T>
BOOL MatrixEntry<T> :: operator<(MatrixEntry<T> &compare_me)
{
    return getRow() < compare_me.getRow() ||
            getCol() < compare_me.getCol() ? TRUE : FALSE;
}

template <typename T>
BOOL MatrixEntry<T> :: operator>(MatrixEntry<T> &compare_me)
{
    return (*this < compare_me) == FALSE ? TRUE : FALSE;
}

template <typename T>
BOOL MatrixEntry<T> :: operator==(MatrixEntry<T> &compare_me)
{
    return getRow() == compare_me.getRow() &&
            getCol() == compare_me.getCol() ? TRUE : FALSE;
}


#endif
